home *** CD-ROM | disk | FTP | other *** search
/ SuperHack / SuperHack CD.bin / CODING / C / CSOURCE.ZIP / DISSOLVE.C < prev    next >
Encoding:
C/C++ Source or Header  |  1994-07-07  |  6.5 KB  |  228 lines
  1. /****************************************************************
  2. * FILE:    dissolve.c
  3. * DESC:    This file accepts two PCX files and does a dissolve
  4. *        between them.
  5. * 
  6. * HISTORY:    Created     7/03/1994
  7. * LAST CHANGED: 7/03/1994
  8. * 
  9. *    Copyright (c) 1994 by Scott Anderson
  10. *
  11. ****************************************************************/
  12.  
  13. /* ----------------------INCLUDES----------------------------- */
  14.  
  15. #include <conio.h>
  16. #include <stdio.h>
  17. #include <io.h>
  18. #include <math.h>
  19. #include <graph.h>
  20. #include <malloc.h>
  21. #include <memory.h>
  22. #include <string.h>
  23.  
  24. #include "define.h"
  25.  
  26. /* ----------------------DEFINES------------------------------ */
  27.  
  28. #define DISSOLVE_TWEENS    1
  29.  
  30. /* ----------------------PROTOTYPES--------------------------- */
  31.  
  32. int    getColor(PICTURE *pic, int x, int y, COLOR *color);
  33. int        tweenDissolve(PICTURE *src, PICTURE *dst);
  34.  
  35. /* ----------------------EXTERNALS---------------------------- */
  36.  
  37. /**** color routines ****/
  38. extern int        closestColor(int r, int g, int b, PALETTE *palPtr);
  39. extern void        collapseColors(PALETTE *palPtr);
  40.  
  41. /**** other variables ****/ 
  42. /* ID of palette currently being displayed */
  43. extern int         CurrentPal;
  44.  
  45. extern char        *OutFilename;
  46.  
  47. /* set from last picture loaded */
  48. extern int        Xmin, Ymin, Xmax, Ymax;
  49.  
  50. /***** variables used to compute intermediate images ****/
  51. /* number of colors in tweened image before reduction*/
  52. extern int         Ncolors;
  53.  
  54. /* r, g, b frequency counter array */
  55. extern unsigned int far Freq[MAX_COMP][MAX_COMP][MAX_COMP];
  56.  
  57. /* tweened images red, grn, and blu components*/
  58. extern unsigned char far Red[MAX_WIDE][MAX_TALL];
  59. extern unsigned char far Grn[MAX_WIDE][MAX_TALL];
  60. extern unsigned char far Blu[MAX_WIDE][MAX_TALL];
  61.  
  62. extern PALETTE TweenPal;            /* resulting palette */
  63.  
  64. /* ----------------------GLOBAL DATA--------------------------- */
  65.  
  66. PICTURE *Src;        /* source & destination picture pointers */
  67. PICTURE *Dst;
  68.  
  69. int        Tweens;
  70.  
  71. /*****************************************************************
  72. * FUNC: main (int argc, char *argv[])
  73. * 
  74. * DESC: Read in a filename to load
  75. *****************************************************************/
  76.  
  77. main (int argc, char *argv[])
  78. {
  79.     int        segment;
  80.  
  81.     /* load the pcx file if one is given */
  82.     if ((3 > argc) || (argc > 5)) {
  83.         printf("Usage: dissolve <source> <dest> [<steps> [<output>]]\n\n");
  84.         printf("Where: <source> is the source PCX filename\n");
  85.         printf("       <dest>   is the destination filename\n");
  86.         printf("       <steps>  is the optional sequence size\n");
  87.         printf("                (the max is %d, the default is %d)\n",
  88.                                 MAX_TWEENS, DISSOLVE_TWEENS+2);
  89.         printf("       <output> is the optional output filename\n");
  90.         printf("                (defaults to no output)\n");
  91.         printf("Note:  The output filename can be at most %d characters long.\n",
  92.                                         MAX_NAME_SIZE);
  93.         printf("       The PCX extension is added automatically, so don't\n");
  94.         printf("       include it in the filename.\n");
  95.         printf("       Morph only accepts PCX files with %d X %d resolution\n",
  96.                                         MAX_WIDE, MAX_TALL);
  97.         printf("       and %d colors.\n", COLORS);
  98.         exit(0);
  99.     }
  100.     if (argc > 3) {
  101.         /* subtract two from the sequence count (for the source
  102.             and target) to get the tween count */
  103.         Tweens = clip (atoi(argv[3]) - 2, 1, MAX_TWEENS);
  104.         if (argc > 4)
  105.             OutFilename = argv[4];
  106.     }
  107.     else
  108.         Tweens = DISSOLVE_TWEENS;
  109.     printf("Loading the file %s\n", argv[1]);
  110.     Src = loadPicture(argv[1]);
  111.     if (Src == NULL)
  112.         quit(MEMORY_ERR, "");
  113.     printf("Loading the file %s\n", argv[2]);
  114.     Dst = loadPicture(argv[2]);
  115.     if (Dst == NULL)
  116.         quit(MEMORY_ERR, "");
  117.  
  118.     setGraphicsMode();
  119.     tweenDissolve(Src, Dst);
  120.     setTextMode();
  121. }
  122.  
  123. /*****************************************************************
  124. * FUNC: int    tweenDissolve(PICTURE *src, PICTURE *dst)
  125. * 
  126. * DESC: calculate a pixel to plot, from the warping function
  127. *****************************************************************/
  128.  
  129. #define TOTAL_WEIGHT        (100)    /* Good for up to 99 tweens */
  130.  
  131. tweenDissolve(PICTURE *src, PICTURE *dst)
  132. {
  133.     int color;
  134.     int    x,y;
  135.     COLOR scolor, dcolor;
  136.     int t, i, p;
  137.     int r, g, b;
  138.     unsigned int srcweight, srcpaletteindex;
  139.     unsigned int dstweight, dstpaletteindex;
  140.  
  141.     displayPicture(src);
  142.     saveScreen(&src->pal);
  143.  
  144.     /* src is on screen, now tween to the target */
  145.     for (t = 1; t <= Tweens; t++) {
  146.         dstweight = t * TOTAL_WEIGHT / (Tweens+1);
  147.         srcweight = TOTAL_WEIGHT - dstweight;
  148.  
  149.         /* Zero out the buffers */
  150.         initFreq();
  151.         _fmemset(Red, 0, sizeof Red);
  152.         _fmemset(Grn, 0, sizeof Grn);
  153.         _fmemset(Blu, 0, sizeof Blu);
  154.  
  155.         /* Go through the screen positions */
  156.         for (y = Ymin; y <= Ymax; y++)    {
  157.             if (quitCheck())
  158.                 quit(0, "");
  159.             for (x = Xmin; x <= Xmax; x++)    {    
  160.                 getColor(src, x, y, &scolor);
  161.                 getColor(dst, x, y, &dcolor);
  162.                 r = (scolor.r * srcweight +    dcolor.r * dstweight)
  163.                                 / TOTAL_WEIGHT;
  164.                 g = (scolor.g * srcweight +    dcolor.g * dstweight)
  165.                                 / TOTAL_WEIGHT;
  166.                 b = (scolor.b * srcweight +    dcolor.b * dstweight)
  167.                                 / TOTAL_WEIGHT;
  168.                 if (Freq[r][g][b] == 0)        /* A new color */
  169.                     Ncolors++;
  170.                 /* Keep it to one byte */
  171.                 if (Freq[r][g][b] < MAX_FREQ)
  172.                     Freq[r][g][b]++;
  173.                 /* put the RGB components of each pixel into a
  174.                                         temporary screen buffer */
  175.                 Red[x][y] = r;
  176.                 Grn[x][y] = g;
  177.                 Blu[x][y] = b;
  178.             }
  179.         }
  180.         collapseColors(&TweenPal);
  181.         setPalette(&TweenPal);
  182.  
  183.         for (y = Ymin; y <= Ymax; y++)    {
  184.             if (quitCheck())
  185.                 quit(0, "");
  186.             for (x = Xmin; x <= Xmax; x++)    {
  187.                 color = closestColor(    Red[x][y],
  188.                                         Grn[x][y],
  189.                                         Blu[x][y],
  190.                                         &TweenPal);
  191.                 _setcolor (color);
  192.                 _setpixel (x, y);
  193.             }
  194.         }
  195.         if (!OutFilename) {    /* no output file name was given */
  196.             beep();
  197.             beep();
  198.             waitForKey();    /* so pause to enjoy the pictures */
  199.         }
  200.         else
  201.             saveScreen(&TweenPal);
  202.     }
  203.     CurrentPal = 0;         /* force a new palette */
  204.     displayPicture(dst);
  205.     saveScreen(&dst->pal);
  206. }
  207.  
  208. /*****************************************************************
  209. * FUNC: int    getColor(PICTURE *pic, int x, int y, COLOR *color)
  210. * 
  211. * DESC: Return the index and the RGB color at the given
  212. *        x,y coordinate.
  213. *****************************************************************/
  214.  
  215. int
  216. getColor(PICTURE *picture, int x, int y, COLOR *color)
  217. {
  218.     int        paletteIndex;
  219.  
  220.     paletteIndex = PIXEL (picture, x, y);
  221.     color->r = picture->pal.c[paletteIndex].r;
  222.     color->g = picture->pal.c[paletteIndex].g;
  223.     color->b = picture->pal.c[paletteIndex].b;
  224.     return (paletteIndex);
  225. }
  226.  
  227.  
  228.